#!/usr/bin/env node

/**
 * 🔍 PPH系统生产环境部署前检查脚本
 * 
 * 功能：
 * 1. 检查Node.js版本
 * 2. 检查部署包完整性
 * 3. 检查是否存在简化程序、测试文件、mock数据
 * 4. 验证生产环境配置
 * 5. 检查端口占用
 * 6. 验证数据库文件
 */

const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

class ProductionChecker {
  constructor() {
    this.errors = [];
    this.warnings = [];
    this.projectRoot = path.resolve(__dirname, '..');
  }

  // 检查Node.js版本
  checkNodeVersion() {
    console.log('🔍 检查Node.js版本...');
    
    try {
      const version = process.version;
      console.log(`当前Node.js版本: ${version}`);
      
      if (!version.startsWith('v18.17.1')) {
        this.errors.push(`❌ Node.js版本错误: ${version}，必须使用 v18.17.1`);
        this.errors.push('   解决方案: nvm use 18.17.1');
      } else {
        console.log('✅ Node.js版本正确');
      }
    } catch (error) {
      this.errors.push(`❌ 无法检查Node.js版本: ${error.message}`);
    }
  }

  // 检查垃圾文件
  checkGarbageFiles() {
    console.log('🔍 检查垃圾文件...');
    
    const blacklist = ['simple', 'test', 'mock', 'debug', 'sample'];
    const garbageFiles = [];
    
    const scanDir = (dir) => {
      try {
        const items = fs.readdirSync(dir);
        for (const item of items) {
          if (item === 'node_modules' || item === '.git') continue;
          
          const fullPath = path.join(dir, item);
          const stat = fs.statSync(fullPath);
          
          if (stat.isDirectory()) {
            scanDir(fullPath);
          } else {
            const fileName = path.basename(fullPath).toLowerCase();
            const relativePath = path.relative(this.projectRoot, fullPath);
            
            // 检查是否是垃圾文件
            const isGarbage = blacklist.some(keyword => fileName.includes(keyword)) &&
                             !fileName.includes('.forbidden') &&
                             fileName !== 'server-simple.cjs' &&
                             fileName !== 'static-server.cjs' &&
                             fileName !== 'production-check.cjs' &&
                             !relativePath.includes('node_modules') &&
                             !relativePath.includes('logs');
            
            if (isGarbage) {
              garbageFiles.push(relativePath);
            }
          }
        }
      } catch (error) {
        this.warnings.push(`⚠️ 无法扫描目录 ${dir}: ${error.message}`);
      }
    };
    
    scanDir(this.projectRoot);
    
    if (garbageFiles.length > 0) {
      this.errors.push('❌ 发现垃圾文件:');
      garbageFiles.forEach(file => {
        this.errors.push(`   - ${file}`);
      });
      this.errors.push('   解决方案: 删除上述文件');
    } else {
      console.log('✅ 未发现垃圾文件');
    }
  }

  // 检查必要文件
  checkRequiredFiles() {
    console.log('🔍 检查必要文件...');
    
    const requiredFiles = [
      'app/backend/server-simple.cjs',
      'app/backend/package.json',
      'app/backend/data/pph.sqlite',
      'app/frontend/dist/index.html',
      'management/server.js',
      'management/package.json',
      'config/ecosystem.config.cjs'
    ];
    
    for (const file of requiredFiles) {
      const fullPath = path.join(this.projectRoot, file);
      if (!fs.existsSync(fullPath)) {
        this.errors.push(`❌ 缺少必要文件: ${file}`);
      }
    }
    
    console.log('✅ 必要文件检查完成');
  }

  // 检查端口占用
  checkPortOccupation() {
    console.log('🔍 检查端口占用...');
    
    const ports = [3010, 3011, 3012];
    
    for (const port of ports) {
      try {
        const result = execSync(`netstat -ano | findstr :${port}`, { encoding: 'utf8' });
        if (result.trim()) {
          this.warnings.push(`⚠️ 端口 ${port} 被占用:`);
          this.warnings.push(`   ${result.trim()}`);
          this.warnings.push(`   解决方案: taskkill /f /im node.exe`);
        }
      } catch (error) {
        // 端口未被占用，这是好事
      }
    }
    
    console.log('✅ 端口检查完成');
  }

  // 检查数据库
  checkDatabase() {
    console.log('🔍 检查数据库文件...');
    
    const dbPath = path.join(this.projectRoot, 'app/backend/data/pph.sqlite');
    
    if (!fs.existsSync(dbPath)) {
      this.errors.push('❌ 数据库文件不存在: app/backend/data/pph.sqlite');
      return;
    }
    
    const stats = fs.statSync(dbPath);
    if (stats.size < 1024) {
      this.warnings.push('⚠️ 数据库文件过小，可能是空数据库');
    }
    
    console.log(`✅ 数据库文件存在 (${Math.round(stats.size / 1024)}KB)`);
  }

  // 检查PM2
  checkPM2() {
    console.log('🔍 检查PM2...');
    
    try {
      execSync('pm2 --version', { stdio: 'pipe' });
      console.log('✅ PM2已安装');
    } catch (error) {
      this.errors.push('❌ PM2未安装');
      this.errors.push('   解决方案: npm install -g pm2');
    }
  }

  // 生成报告
  generateReport() {
    console.log('\n' + '='.repeat(60));
    console.log('📋 PPH系统生产环境检查报告');
    console.log('='.repeat(60));
    
    if (this.errors.length === 0 && this.warnings.length === 0) {
      console.log('🎉 恭喜！所有检查都通过了，可以安全部署到生产环境！');
      console.log('\n🚀 建议的部署命令:');
      console.log('   cd /d "D:\\PPH-Production-Deploy"');
      console.log('   npx pm2 start "config\\ecosystem.config.cjs" --env production');
      return true;
    }
    
    if (this.errors.length > 0) {
      console.log('\n❌ 发现严重错误，必须修复后才能部署:');
      this.errors.forEach(error => console.log(error));
    }
    
    if (this.warnings.length > 0) {
      console.log('\n⚠️ 发现警告，建议处理:');
      this.warnings.forEach(warning => console.log(warning));
    }
    
    console.log('\n💡 修复所有问题后重新运行此脚本进行检查。');
    return false;
  }

  // 运行所有检查
  runAllChecks() {
    console.log('🔍 开始PPH系统生产环境检查...\n');
    
    this.checkNodeVersion();
    this.checkGarbageFiles();
    this.checkRequiredFiles();
    this.checkPortOccupation();
    this.checkDatabase();
    this.checkPM2();
    
    return this.generateReport();
  }
}

// 主函数
function main() {
  const checker = new ProductionChecker();
  const success = checker.runAllChecks();
  
  process.exit(success ? 0 : 1);
}

// 如果直接运行此脚本
if (require.main === module) {
  main();
}

module.exports = ProductionChecker;
